home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / calendar.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  9KB  |  277 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Calendar printing functions
  5.  
  6. Note when comparing these calendars to the ones printed by cal(1): By
  7. default, these calendars have Monday as the first day of the week, and
  8. Sunday as the last (the European convention). Use setfirstweekday() to
  9. set the first day of the week (0=Monday, 6=Sunday).'''
  10. import datetime
  11. __all__ = [
  12.     'error',
  13.     'setfirstweekday',
  14.     'firstweekday',
  15.     'isleap',
  16.     'leapdays',
  17.     'weekday',
  18.     'monthrange',
  19.     'monthcalendar',
  20.     'prmonth',
  21.     'month',
  22.     'prcal',
  23.     'calendar',
  24.     'timegm',
  25.     'month_name',
  26.     'month_abbr',
  27.     'day_name',
  28.     'day_abbr',
  29.     'weekheader']
  30. error = ValueError
  31. January = 1
  32. February = 2
  33. mdays = [
  34.     0,
  35.     31,
  36.     28,
  37.     31,
  38.     30,
  39.     31,
  40.     30,
  41.     31,
  42.     31,
  43.     30,
  44.     31,
  45.     30,
  46.     31]
  47.  
  48. class _localized_month:
  49.     _months = [ datetime.date(2001, i + 1, 1).strftime for i in range(12) ]
  50.     _months.insert(0, (lambda x: ''))
  51.     
  52.     def __init__(self, format):
  53.         self.format = format
  54.  
  55.     
  56.     def __getitem__(self, i):
  57.         funcs = self._months[i]
  58.  
  59.     
  60.     def __len__(self):
  61.         return 13
  62.  
  63.  
  64.  
  65. class _localized_day:
  66.     _days = [ datetime.date(2001, 1, i + 1).strftime for i in range(7) ]
  67.     
  68.     def __init__(self, format):
  69.         self.format = format
  70.  
  71.     
  72.     def __getitem__(self, i):
  73.         funcs = self._days[i]
  74.  
  75.     
  76.     def __len__(self):
  77.         return 7
  78.  
  79.  
  80. day_name = _localized_day('%A')
  81. day_abbr = _localized_day('%a')
  82. month_name = _localized_month('%B')
  83. month_abbr = _localized_month('%b')
  84. (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)
  85. _firstweekday = 0
  86.  
  87. def firstweekday():
  88.     return _firstweekday
  89.  
  90.  
  91. def setfirstweekday(weekday):
  92.     '''Set weekday (Monday=0, Sunday=6) to start each week.'''
  93.     global _firstweekday
  94.     if weekday <= weekday:
  95.         pass
  96.     elif not weekday <= SUNDAY:
  97.         raise ValueError, 'bad weekday number; must be 0 (Monday) to 6 (Sunday)'
  98.     
  99.     _firstweekday = weekday
  100.  
  101.  
  102. def isleap(year):
  103.     '''Return 1 for leap years, 0 for non-leap years.'''
  104.     if not year % 4 == 0 and year % 100 != 0:
  105.         pass
  106.     return year % 400 == 0
  107.  
  108.  
  109. def leapdays(y1, y2):
  110.     '''Return number of leap years in range [y1, y2).
  111.        Assume y1 <= y2.'''
  112.     y1 -= 1
  113.     y2 -= 1
  114.     return (y2 // 4 - y1 // 4 - y2 // 100 - y1 // 100) + (y2 // 400 - y1 // 400)
  115.  
  116.  
  117. def weekday(year, month, day):
  118.     '''Return weekday (0-6 ~ Mon-Sun) for year (1970-...), month (1-12),
  119.        day (1-31).'''
  120.     return datetime.date(year, month, day).weekday()
  121.  
  122.  
  123. def monthrange(year, month):
  124.     '''Return weekday (0-6 ~ Mon-Sun) and number of days (28-31) for
  125.        year, month.'''
  126.     if month <= month:
  127.         pass
  128.     elif not month <= 12:
  129.         raise ValueError, 'bad month number'
  130.     
  131.     day1 = weekday(year, month, 1)
  132.     if month == February:
  133.         pass
  134.     ndays = mdays[month] + isleap(year)
  135.     return (day1, ndays)
  136.  
  137.  
  138. def monthcalendar(year, month):
  139.     """Return a matrix representing a month's calendar.
  140.        Each row represents a week; days outside this month are zero."""
  141.     (day1, ndays) = monthrange(year, month)
  142.     rows = []
  143.     r7 = range(7)
  144.     day = ((_firstweekday - day1) + 6) % 7 - 5
  145.     while day <= ndays:
  146.         row = [
  147.             0,
  148.             0,
  149.             0,
  150.             0,
  151.             0,
  152.             0,
  153.             0]
  154.         for i in r7:
  155.             if day <= day:
  156.                 pass
  157.             elif day <= ndays:
  158.                 row[i] = day
  159.             
  160.             day = day + 1
  161.         
  162.         rows.append(row)
  163.         continue
  164.         1
  165.     return rows
  166.  
  167.  
  168. def prweek(theweek, width):
  169.     '''Print a single week (no newline).'''
  170.     print week(theweek, width),
  171.  
  172.  
  173. def week(theweek, width):
  174.     '''Returns a single week in a string (no newline).'''
  175.     days = []
  176.     for day in theweek:
  177.         if day == 0:
  178.             s = ''
  179.         else:
  180.             s = '%2i' % day
  181.         days.append(s.center(width))
  182.     
  183.     return ' '.join(days)
  184.  
  185.  
  186. def weekheader(width):
  187.     '''Return a header for a week.'''
  188.     if width >= 9:
  189.         names = day_name
  190.     else:
  191.         names = day_abbr
  192.     days = []
  193.     for i in range(_firstweekday, _firstweekday + 7):
  194.         days.append(names[i % 7][:width].center(width))
  195.     
  196.     return ' '.join(days)
  197.  
  198.  
  199. def prmonth(theyear, themonth, w = 0, l = 0):
  200.     """Print a month's calendar."""
  201.     print month(theyear, themonth, w, l),
  202.  
  203.  
  204. def month(theyear, themonth, w = 0, l = 0):
  205.     """Return a month's calendar string (multi-line)."""
  206.     w = max(2, w)
  207.     l = max(1, l)
  208.     s = ('%s %r' % (month_name[themonth], theyear)).center(7 * (w + 1) - 1).rstrip() + '\n' * l + weekheader(w).rstrip() + '\n' * l
  209.     for aweek in monthcalendar(theyear, themonth):
  210.         s = s + week(aweek, w).rstrip() + '\n' * l
  211.     
  212.     return s[:-l] + '\n'
  213.  
  214. _colwidth = 7 * 3 - 1
  215. _spacing = 6
  216.  
  217. def format3c(a, b, c, colwidth = _colwidth, spacing = _spacing):
  218.     '''Prints 3-column formatting for year calendars'''
  219.     print format3cstring(a, b, c, colwidth, spacing)
  220.  
  221.  
  222. def format3cstring(a, b, c, colwidth = _colwidth, spacing = _spacing):
  223.     '''Returns a string formatted from 3 strings, centered within 3 columns.'''
  224.     return a.center(colwidth) + ' ' * spacing + b.center(colwidth) + ' ' * spacing + c.center(colwidth)
  225.  
  226.  
  227. def prcal(year, w = 0, l = 0, c = _spacing):
  228.     """Print a year's calendar."""
  229.     print calendar(year, w, l, c),
  230.  
  231.  
  232. def calendar(year, w = 0, l = 0, c = _spacing):
  233.     """Returns a year's calendar as a multi-line string."""
  234.     w = max(2, w)
  235.     l = max(1, l)
  236.     c = max(2, c)
  237.     colwidth = (w + 1) * 7 - 1
  238.     s = repr(year).center(colwidth * 3 + c * 2).rstrip() + '\n' * l
  239.     header = weekheader(w)
  240.     header = format3cstring(header, header, header, colwidth, c).rstrip()
  241.     for q in range(January, January + 12, 3):
  242.         s = s + '\n' * l + format3cstring(month_name[q], month_name[q + 1], month_name[q + 2], colwidth, c).rstrip() + '\n' * l + header + '\n' * l
  243.         data = []
  244.         height = 0
  245.         for amonth in range(q, q + 3):
  246.             cal = monthcalendar(year, amonth)
  247.             if len(cal) > height:
  248.                 height = len(cal)
  249.             
  250.             data.append(cal)
  251.         
  252.         for i in range(height):
  253.             weeks = []
  254.             for cal in data:
  255.                 if i >= len(cal):
  256.                     weeks.append('')
  257.                     continue
  258.                 weeks.append(week(cal[i], w))
  259.             
  260.             s = s + format3cstring(weeks[0], weeks[1], weeks[2], colwidth, c).rstrip() + '\n' * l
  261.         
  262.     
  263.     return s[:-l] + '\n'
  264.  
  265. EPOCH = 1970
  266. _EPOCH_ORD = datetime.date(EPOCH, 1, 1).toordinal()
  267.  
  268. def timegm(tuple):
  269.     '''Unrelated but handy function to calculate Unix timestamp from GMT.'''
  270.     (year, month, day, hour, minute, second) = tuple[:6]
  271.     days = (datetime.date(year, month, 1).toordinal() - _EPOCH_ORD) + day - 1
  272.     hours = days * 24 + hour
  273.     minutes = hours * 60 + minute
  274.     seconds = minutes * 60 + second
  275.     return seconds
  276.  
  277.